/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "list元素插座.h"
#include "list物体插座.h"
#include "list数值插座.h"
#include "../C_物体插座.h"



C_Vector_模板::C_Vector_模板(string name)
	:C_插座基类(name, E_插座类型::e_插座Type_Vector模板)
{
	m_引用数据 = 0;
}

C_Vector_模板::~C_Vector_模板()
{
}

void* C_Vector_模板::f_getData() {
	C_插座基类* socket = f_getLinkOutSocket();
	if (socket) {
		if (socket->m_Type == E_插座类型::e_插座Type_Vector模板) {
			return socket->f_getData();
		}
		return socket;
		/*switch (socket->m_插座类型) {
		case E_插座类型::e_插座Type_VectorFloat32:
			break;
		case E_插座类型::e_插座Type_VectorInt32:
			break;
		case E_插座类型::e_插座Type_VectorUInt32:
			break;
		case E_插座类型::e_插座Type_VectorInt64:
			break;
		case E_插座类型::e_插座Type_VectorVec2:
			break;
		case E_插座类型::e_插座Type_VectorVec3:
			break;
		case E_插座类型::e_插座Type_VectorVec4:
			break;
		case E_插座类型::e_插座Type_VectorVec2i:
			break;
		case E_插座类型::e_插座Type_VectorVec3i:
			break;
		case E_插座类型::e_插座Type_VectorVec4i:
			break;
		case E_插座类型::e_插座Type_VectorObject:
			break;
		case E_插座类型::e_插座Type_Mesh_Array1D:
			break;
		case E_插座类型::e_插座Type_VectorLine:
			break;
		case E_插座类型::e_插座Type_VectorParticle:
			break;
		case E_插座类型::e_插座Type_VectorScene:
			break;
		default:
			return 0;
		}*/
	}
	return m_引用数据;
}

void C_Vector_模板::f_setData(void * data, int64 ID) {
#ifdef _DEBUG
	if (typeid(data).name() == "C_插座基类") {
		cout << "严重错误 模板插座只能取数据" << endl;
	}
#endif

	m_引用数据 = data;
	
}











/*C_引用数据插座::C_引用数据插座(string name)
	:C_插座基类(name, E_插座类型::e_插座Type_引用数据)
{
	m_引用数据.m_Data = 0;
	m_引用数据.m_Type = E_插座类型::e_插座Type_Bool;
}

C_引用数据插座::~C_引用数据插座()
{
}

void* C_引用数据插座::f_getData() {
	C_插座基类* socket = f_getLinkOutSocket();
	if (socket) {
		switch (socket->m_Type) {
		case E_插座类型::e_插座Type_引用数据:
			m_引用数据 = *DEF_转换为引用数据(socket);
			break;
		default:
			m_引用数据.m_Data = socket->f_getData();
			m_引用数据.m_Type = socket->m_Type;
			break;
		}
		//return socket->f_getData();
	}
	return &m_引用数据;
}


vec3 C_引用数据插座::f_getVec3() {
	auto& data = *DEF_转换为引用数据(this);
	if (data.m_Type == E_插座类型::e_插座Type_Vec3) {
		return *((vec3*)data.m_Data);
	}
	return vec3();
}

vector<int8>* C_引用数据插座::f_getI8_1D(const int64& ID) {
	auto& data = *DEF_转换为引用数据(this);
	if (data.m_Type == E_插座类型::e_插座Type_I8_Array1D) {
		return ((vector<int8>*)data.m_Data);
	}
	return nullptr;
}

vector<float32>* C_引用数据插座::f_getF32_1D(const int64& ID) {
	auto& data = *DEF_转换为引用数据(this);
	if (data.m_Type == E_插座类型::e_插座Type_F32_Array1D) {
		return ((vector<float32>*)data.m_Data);
	}
	return nullptr;
}

vector<vec3>* C_引用数据插座::f_getVec3_1D(const int64& ID) {
	auto& data = *DEF_转换为引用数据(this);
	if (data.m_Type == E_插座类型::e_插座Type_Vec3_Array1D) {
		return ((vector<vec3>*)data.m_Data);
	}
	return nullptr;
}



void C_引用数据插座::f_setData(void* data, int64 ID) {
	m_引用数据 = *((S_引用插座数据映射*)data);
}

PyObject* C_引用数据插座::f_输出_bl数据(PyObject* bl_data) {
	PyObject* data = 0;

	if (!m_引用数据.m_Data) return 0;

	if (bl_data == (PyObject*)0xffffffff) {
		switch (m_引用数据.m_Type) {
		case E_插座类型::e_插座Type_Mesh:
			data = f_构建Py网格数据(*((S_网格插座数据*)m_引用数据.m_Data));
			break;
		case E_插座类型::e_插座Type_Mesh_Array1D:
			data = f_构建PyArray1D网格数据(*((vector<S_网格插座数据>*)m_引用数据.m_Data));
			break;
		case E_插座类型::e_插座Type_F32_Array1D:
			data = f_F32_Array1D_输出_bl数据(*((vector<float32>*)m_引用数据.m_Data), (PyObject*)1);
			break;
		case E_插座类型::e_插座Type_F32_Array2D:
			data = f_F32_Array2D_输出_bl数据(*((vector<vector<float32>>*)m_引用数据.m_Data), (PyObject*)1);
			break;
		case E_插座类型::e_插座Type_I32_Array1D:
			data = f_I32_Array1D_输出_bl数据(*((vector<int32>*)m_引用数据.m_Data));
			break;
		case E_插座类型::e_插座Type_Array元素:

			break;
		case E_插座类型::e_插座Type_Vec3i:

			break;
		case E_插座类型::e_插座Type_Int32:
			data = Py_BuildValue("[i]", *((int32*)m_引用数据.m_Data));
			break;
		case E_插座类型::e_插座Type_UInt32:
			data = Py_BuildValue("[i]", *((uint32*)m_引用数据.m_Data));
			break;
		case E_插座类型::e_插座Type_Float32:
			data = Py_BuildValue("[f]", *((float32*)m_引用数据.m_Data));
			break;
		default:
			break;
		}
		
	}
	return data;
}






void f_引用插座绑定数据(C_插座基类* 引用插座, C_插座基类* 数据插座, E_数据赋值方式 赋值方式, int64 位置) {
	auto& mapData = *DEF_转换为引用数据(引用插座);

	mapData.m_添加方式 = 赋值方式;
	mapData.m_位置索引.x = 位置;

	C_插座基类* socket = 数据插座->f_getLinkOutSocket();
	mapData.m_Data = socket->f_getData();
	mapData.m_Type = socket->m_Type;
}

void f_引用插座绑定数据(C_插座基类* 引用插座, void* 数据插座, E_插座类型 type, E_数据赋值方式 赋值方式, int64 位置) {
	auto& mapData = *DEF_转换为引用数据(引用插座);

	mapData.m_添加方式 = 赋值方式;
	mapData.m_位置索引.x = 位置;

	mapData.m_Data = 数据插座;
	mapData.m_Type = type;
}*/














C_1dArray_元素::C_1dArray_元素(string name)
	:C_插座基类(name, E_插座类型::e_插座Type_Array元素)
{

}


C_1dArray_元素::~C_1dArray_元素()
{
}

void * C_1dArray_元素::f_getData()
{
	return nullptr;
}

void C_1dArray_元素::f_setData(void* data, int64 ID) {

}

